package com.example.day2;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.IntPredicate;
import java.util.function.Supplier;

/**
 * 函数接口
 */
public class CategoryTest {
    public static void main(String[] args) {
        // 使用自定义的函数式接口类型
        // Type1 obj1 = a -> (a & 1) == 0;
        // Type1 obj2 = a -> BigInteger.valueOf(a).isProbablePrime(100); // isProbablePrime该方法判断一个数是否是质数
        // Type2 obj3 = (a, b, c) -> a + b + c;
        // Type3 obj4 = (a, b) -> a - b;
        // Type3 obj5 = (a, b) -> a * b;
        // Type6<Student> obj6 = () -> new Student();
        // Type6<List<Student>> obj7 = () -> new ArrayList<Student>();
        // Type7<String, Student> obj8 = s -> s.getName();
        // Type7<Integer, Student> obj9 = s -> s.getAge();

        // 使用JDK中提供的函数式接口类型
        // IntPredicate是jdk中提供的函数式接口,接收一个int参数,返回一个boolean结果
        IntPredicate obj1 = a -> (a & 1) == 0;
        IntPredicate obj2 = a -> BigInteger.valueOf(a).isProbablePrime(100); // isProbablePrime该方法判断一个数是否是质数
        IntTernaryOperator obj3 = (a, b, c) -> a + b + c;

        // IntBinaryOperator是jdk中提供的函数式接口,接收两个int参数,返回一个int结果
        IntBinaryOperator obj4 = (a, b) -> a - b;
        IntBinaryOperator obj5 = (a, b) -> a * b;

        // Supplier是jdk中提供的函数式接口,无参数,返回一个结果
        Supplier<Student> obj6 = () -> new Student();
        Supplier<List<Student>> obj7 = () -> new ArrayList<Student>();

        // Function是jdk中提供的函数式接口,接收一个参数,返回一个结果 其中第一个泛型表示方法的参数类型 第二个泛型表示返回类型
        Function<Student, String> obj8 = s -> s.getName();
        Function<Student, Integer> obj9 = s -> s.getAge();
    }

    @FunctionalInterface
    interface Type1 {
        boolean operate(int a);
    }

    // 函数式接口起名规范
    // 首先该函数式接口只是用于处理基本类型的数据就使用Int开头,其次是接收三个参数就使用Ternary
    // 最后参数和返回值类型都一致使用Operator
    @FunctionalInterface
    interface IntTernaryOperator {
        int operate(int a, int b, int c);
    }

    @FunctionalInterface
    interface Type3 {
        int operate(int a, int b);
    }

    @FunctionalInterface
    interface Type4 {
        Student operate();
    }

    @FunctionalInterface
    interface Type5 {
        List<Student> operate();
    }

    // 抽取函数式接口,Type4和Type5只是返回类型不同其余都是相同的,为了提高复用性使用泛型
    @FunctionalInterface
    interface Type6<T> {
        T operate();
    }

    // O表示返回类型 I表示参数类型
    @FunctionalInterface
    interface Type7<O, I> {
        O operate(I i);
    }


    static class Student {
        private String name;
        private String sex;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }
}
